home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / target_s.swf / scripts / playerEngine.as < prev    next >
Encoding:
Text File  |  2008-11-13  |  22.5 KB  |  724 lines
  1. package
  2. {
  3.    import assets.effects.blood;
  4.    import assets.effects.star1;
  5.    import flash.display.*;
  6.    import flash.events.*;
  7.    import flash.filters.*;
  8.    import flash.utils.Timer;
  9.    
  10.    public class playerEngine extends MovieClip
  11.    {
  12.        
  13.       
  14.       public var snum:Number = 1;
  15.       
  16.       public var action:Boolean = true;
  17.       
  18.       public var contact:Boolean = true;
  19.       
  20.       public var airTime:Boolean = false;
  21.       
  22.       public var shad:MovieClip;
  23.       
  24.       public var cnum:Number = 1;
  25.       
  26.       public var scope:Object;
  27.       
  28.       public var pos:Object;
  29.       
  30.       public var pump:Boolean = false;
  31.       
  32.       public var skater:MovieClip;
  33.       
  34.       public var ramping:Boolean = false;
  35.       
  36.       public var rampObj:MovieClip;
  37.       
  38.       public var dnum:Number = 1;
  39.       
  40.       public var tscore:Number = 0;
  41.       
  42.       public var wnum:Number = 1;
  43.       
  44.       private var recoveryTimer:Timer;
  45.       
  46.       public var skaterFX:MovieClip;
  47.       
  48.       public var momentumV:Number;
  49.       
  50.       public var smode:Number = 0;
  51.       
  52.       public var base:Number = 350;
  53.       
  54.       public var fore:Boolean = false;
  55.       
  56.       public var impactV:Number;
  57.       
  58.       public var minGrindSpeed:Number = 5;
  59.       
  60.       public function playerEngine(param1:*)
  61.       {
  62.          cnum = 1;
  63.          snum = 1;
  64.          dnum = 1;
  65.          wnum = 1;
  66.          pos = {
  67.             "x":200,
  68.             "y":350
  69.          };
  70.          base = 350;
  71.          contact = true;
  72.          pump = false;
  73.          ramping = false;
  74.          smode = 0;
  75.          action = true;
  76.          airTime = false;
  77.          fore = false;
  78.          tscore = 0;
  79.          recoveryTimer = new Timer(2000,1);
  80.          skater = new skeleton();
  81.          shad = new board_shadow();
  82.          skaterFX = new MovieClip();
  83.          minGrindSpeed = 5;
  84.          super();
  85.          scope = param1;
  86.          recoveryTimer.addEventListener(TimerEvent.TIMER,recoverInit);
  87.       }
  88.       
  89.       private function recoverCheck() : Boolean
  90.       {
  91.          var _loc1_:Boolean = false;
  92.          var _loc2_:* = undefined;
  93.          var _loc3_:* = undefined;
  94.          var _loc4_:* = undefined;
  95.          var _loc5_:* = undefined;
  96.          _loc1_ = true;
  97.          _loc2_ = scope.scene.elementArray;
  98.          _loc3_ = 0;
  99.          while(_loc3_ < _loc2_.length)
  100.          {
  101.             if(_loc2_[_loc3_].y - _loc2_[_loc3_].height <= 350 && _loc2_[_loc3_].y >= 350 && _loc2_[_loc3_].x - _loc2_[_loc3_].wide <= 250 + 150)
  102.             {
  103.                if(_loc2_[_loc3_].x + _loc2_[_loc3_].width > 200 + 150)
  104.                {
  105.                   _loc1_ = false;
  106.                   break;
  107.                }
  108.             }
  109.             _loc3_++;
  110.          }
  111.          _loc4_ = scope.scene.foregroundArray;
  112.          _loc5_ = 0;
  113.          while(_loc5_ < _loc4_.length)
  114.          {
  115.             if(_loc4_[_loc5_].objType == 2 && _loc4_[_loc5_].x - _loc4_[_loc5_].wide <= 250 + 150)
  116.             {
  117.                if(_loc4_[_loc5_].x + _loc4_[_loc5_].width > 200 + 150)
  118.                {
  119.                   _loc1_ = false;
  120.                   break;
  121.                }
  122.             }
  123.             _loc5_++;
  124.          }
  125.          return _loc1_;
  126.       }
  127.       
  128.       public function setPlayer() : *
  129.       {
  130.          var _loc1_:* = undefined;
  131.          skater.x = pos.x;
  132.          skater.y = pos.y;
  133.          shad.x = pos.x;
  134.          shad.y = pos.y;
  135.          shad.alpha = 0.5;
  136.          shad.filters = [new BlurFilter(6,6)];
  137.          skaterFX.x = pos.x;
  138.          skaterFX.y = pos.y;
  139.          if(skaterFX.numChildren > 0)
  140.          {
  141.             _loc1_ = 0;
  142.             while(_loc1_ < skaterFX.numChildren)
  143.             {
  144.                skaterFX.removeChildAt(_loc1_);
  145.                _loc1_++;
  146.             }
  147.          }
  148.          scope.addChild(shad);
  149.          scope.addChild(skater);
  150.          scope.addChild(skaterFX);
  151.          scope.sound.startSound("roll",0,9999,0,0);
  152.          action = true;
  153.          contact = true;
  154.          smode = 0;
  155.          starFX(10,20,20,-50);
  156.       }
  157.       
  158.       public function grind() : *
  159.       {
  160.          var _loc1_:Boolean = false;
  161.          _loc1_ = false;
  162.          if(airTime)
  163.          {
  164.             bail();
  165.          }
  166.          else
  167.          {
  168.             if(smode != 3)
  169.             {
  170.                scope.stats.clearTrickFX(true);
  171.                scope.ollieInit = false;
  172.                scope.methodInit = false;
  173.                scope.indyInit = false;
  174.             }
  175.             if(scope.vx > minGrindSpeed)
  176.             {
  177.                if(!scope.key1 && !scope.key2)
  178.                {
  179.                   _loc1_ = true;
  180.                   starFX(1,2,0,0);
  181.                   tscore += 5;
  182.                   if(smode != 3)
  183.                   {
  184.                      skater.rotation = 0;
  185.                      scope.sound.setVolume("roll",0);
  186.                      skater.gotoAndPlay("grind_50-50");
  187.                      scope.stats.initTrickFX("50-50_grind");
  188.                      smode = 3;
  189.                   }
  190.                }
  191.                else if(Boolean(scope.key1) && !scope.key2)
  192.                {
  193.                   _loc1_ = true;
  194.                   starFX(1,2,0,0);
  195.                   tscore += 10;
  196.                   if(smode != 3)
  197.                   {
  198.                      skater.rotation = 0;
  199.                      scope.sound.setVolume("roll",0);
  200.                      skater.gotoAndPlay("grind_tail");
  201.                      scope.stats.initTrickFX("5-0_grind");
  202.                      smode = 3;
  203.                   }
  204.                }
  205.                else if(!scope.key1 && Boolean(scope.key2))
  206.                {
  207.                   _loc1_ = true;
  208.                   starFX(1,2,40,0);
  209.                   tscore += 10;
  210.                   if(smode != 3)
  211.                   {
  212.                      skater.rotation = 0;
  213.                      scope.sound.setVolume("roll",0);
  214.                      skater.gotoAndPlay("grind_nose");
  215.                      scope.stats.initTrickFX("nose_grind");
  216.                      smode = 3;
  217.                   }
  218.                }
  219.             }
  220.             else
  221.             {
  222.                bail();
  223.             }
  224.             if(!_loc1_)
  225.             {
  226.                if(smode == 3)
  227.                {
  228.                   tscore = 0;
  229.                   scope.stats.clearTrickFX(false);
  230.                   bail();
  231.                }
  232.             }
  233.          }
  234.       }
  235.       
  236.       public function removeSkater() : *
  237.       {
  238.          var _loc1_:* = undefined;
  239.          skater.visible = false;
  240.          _loc1_ = new board2();
  241.          _loc1_.x = -113.3;
  242.          _loc1_.y = 9.7;
  243.          skaterFX.addChild(_loc1_);
  244.          shad.x = skater.x - 113.3;
  245.          shad.y = skater.y + 9.7;
  246.          shad.rotation = 0;
  247.          shad.visible = true;
  248.       }
  249.       
  250.       public function bloodFX(param1:*, param2:*, param3:*, param4:*) : *
  251.       {
  252.          var _loc5_:Sprite = null;
  253.          _loc5_ = new blood(scope,param1,param2,param3,param4);
  254.          scope.scene.elementArray.push(_loc5_);
  255.          scope.scene.element.addChild(_loc5_);
  256.       }
  257.       
  258.       private function recover(param1:Event) : *
  259.       {
  260.          skater.visible = shad.visible = false;
  261.          if(recoverCheck())
  262.          {
  263.             removeEventListener(Event.ENTER_FRAME,recover);
  264.             scope.vx = 0;
  265.             scope.ollieInit = false;
  266.             scope.methodInit = false;
  267.             action = true;
  268.             contact = true;
  269.             skater.gotoAndStop("stand");
  270.             skater.y = shad.y = 350;
  271.             skater.visible = shad.visible = true;
  272.             starFX(10,20,20,-50);
  273.             smode = 0;
  274.          }
  275.          else
  276.          {
  277.             scope.vx = 10;
  278.          }
  279.       }
  280.       
  281.       public function process() : *
  282.       {
  283.          var _loc1_:* = undefined;
  284.          var _loc2_:* = undefined;
  285.          skaterFX.x = skater.x;
  286.          skaterFX.y = skater.y;
  287.          _loc1_ = (100 - (base - skater.y)) / 100;
  288.          if(_loc1_ <= 0)
  289.          {
  290.             _loc1_ = 0;
  291.          }
  292.          shad.scaleX = shad.scaleY = _loc1_;
  293.          switch(smode)
  294.          {
  295.             case 0:
  296.                base = skater.y;
  297.                shad.y = skater.y;
  298.                shad.rotation = skater.rotation;
  299.                _loc2_ = scope.vx / scope.topspd;
  300.                scope.sound.setVolume("roll",_loc2_);
  301.                break;
  302.             case 1:
  303.                skater.y -= scope.vy;
  304.                scope.vy -= scope.gravity;
  305.                if(skater.y >= base)
  306.                {
  307.                   skater.y = base;
  308.                   scope.vy = 0;
  309.                   smode = 0;
  310.                   contact = true;
  311.                   scope.ollieInit = false;
  312.                }
  313.                break;
  314.             case 2:
  315.                skater.y -= scope.vy;
  316.                scope.vy -= scope.gravity;
  317.                scope.vx -= impactV / 20;
  318.                if(skater.y >= base)
  319.                {
  320.                   skater.y = base;
  321.                   scope.vy = 0;
  322.                }
  323.                if(scope.vx <= 1)
  324.                {
  325.                   scope.vx = 0;
  326.                }
  327.                break;
  328.             case 3:
  329.                skater.y -= scope.vy;
  330.                scope.vy -= scope.gravity;
  331.                if(skater.y >= base)
  332.                {
  333.                   scope.stats.clearTrickFX(true);
  334.                   tscore = 0;
  335.                   skater.gotoAndStop("stand");
  336.                   skater.y = base;
  337.                   scope.vy = 0;
  338.                   smode = 0;
  339.                   contact = true;
  340.                }
  341.                break;
  342.             case 4:
  343.                starFX(1,1,0,0);
  344.                skater.y -= scope.vy;
  345.                scope.vy -= scope.gravity;
  346.                if(skater.y >= base)
  347.                {
  348.                   skater.y = base;
  349.                   scope.vy = 0;
  350.                   smode = 0;
  351.                   contact = true;
  352.                   tscore = 0;
  353.                   scope.stats.clearTrickFX(true);
  354.                }
  355.                break;
  356.             case 5:
  357.                starFX(1,1,0,0);
  358.                starFX(1,1,0,-30);
  359.                starFX(1,1,0,-60);
  360.                skater.y -= scope.vy;
  361.                scope.vy -= scope.gravity;
  362.                if(skater.y >= base)
  363.                {
  364.                   if(airTime)
  365.                   {
  366.                      tscore = 0;
  367.                      scope.stats.clearTrickFX(false);
  368.                      bail();
  369.                   }
  370.                   else
  371.                   {
  372.                      skater.y = base;
  373.                      scope.vy = 0;
  374.                      smode = 0;
  375.                      contact = true;
  376.                      tscore = 1000;
  377.                      scope.stats.clearTrickFX(true);
  378.                      tscore = 0;
  379.                      scope.indyInit = false;
  380.                   }
  381.                }
  382.                break;
  383.             case 6:
  384.                starFX(1,1,0,0);
  385.                starFX(1,1,0,-30);
  386.                starFX(1,1,0,-60);
  387.                if(airTime)
  388.                {
  389.                   tscore += 20;
  390.                }
  391.                skater.y -= scope.vy;
  392.                scope.vy -= scope.gravity;
  393.                if(skater.y >= base)
  394.                {
  395.                   if(airTime)
  396.                   {
  397.                      tscore = 0;
  398.                      scope.stats.clearTrickFX(false);
  399.                      skater.board.wheels.visible = true;
  400.                      bail();
  401.                   }
  402.                   else
  403.                   {
  404.                      skater.y = base;
  405.                      scope.vy = 0;
  406.                      smode = 0;
  407.                      contact = true;
  408.                      scope.stats.clearTrickFX(true);
  409.                      tscore = 0;
  410.                      scope.methodInit = false;
  411.                   }
  412.                }
  413.                break;
  414.             case 7:
  415.                skater.y -= scope.vy;
  416.                scope.vy -= scope.gravity;
  417.                if(skater.y >= base)
  418.                {
  419.                   skater.y = base;
  420.                   scope.vy = 0;
  421.                   smode = 0;
  422.                   contact = true;
  423.                }
  424.                break;
  425.             case 10:
  426.                action = false;
  427.                base = 350;
  428.                shad.y = 350;
  429.                shad.x = skater.x;
  430.                if(momentumV > 5)
  431.                {
  432.                   momentumV -= 2;
  433.                }
  434.                else
  435.                {
  436.                   momentumV = 5;
  437.                }
  438.                skater.x += momentumV;
  439.                if(scope.vx > 1)
  440.                {
  441.                   --scope.vx;
  442.                }
  443.                else
  444.                {
  445.                   scope.vx = 0;
  446.                }
  447.                skater.y -= scope.vy;
  448.                scope.vy -= scope.gravity;
  449.                starFX(1,1,20,0);
  450.                starFX(1,1,20,-30);
  451.                starFX(1,1,20,-60);
  452.                if(skater.y >= base)
  453.                {
  454.                   skater.y = base;
  455.                   scope.sound.setVolume("roll",0.5);
  456.                }
  457.                if(skater.x >= 800)
  458.                {
  459.                   scope.levelComplete();
  460.                   scope.vx = 0;
  461.                   smode = 0;
  462.                }
  463.          }
  464.          if(action)
  465.          {
  466.             hitTest();
  467.          }
  468.       }
  469.       
  470.       public function resetCharacter() : *
  471.       {
  472.          var _loc1_:* = undefined;
  473.          var _loc2_:* = undefined;
  474.          if(snum == 3 && dnum == 2)
  475.          {
  476.             snum = 4;
  477.             cnum = 6;
  478.          }
  479.          else
  480.          {
  481.             cnum = 1;
  482.          }
  483.          _loc1_ = 0;
  484.          while(_loc1_ < skater.numChildren)
  485.          {
  486.             _loc2_ = skater.getChildAt(_loc1_);
  487.             _loc2_.gotoAndStop(1);
  488.             _loc1_++;
  489.          }
  490.          skater.board.deck.gotoAndStop(dnum);
  491.          skater.board.wheels.gotoAndStop(wnum);
  492.          skater.gotoAndStop("stand");
  493.          skater.visible = shad.visible = skaterFX.visible = true;
  494.          scope.sound.startSound("roll",0,9999,0,0);
  495.       }
  496.       
  497.       public function bail() : *
  498.       {
  499.          action = false;
  500.          airTime = false;
  501.          impactV = scope.vx;
  502.          base = 340;
  503.          scope.ollieInit = false;
  504.          scope.methodInit = false;
  505.          scope.indyInit = false;
  506.          if(scope.getChildIndex(scope.player.skater) > scope.getChildIndex(scope.scene.foreground))
  507.          {
  508.             scope.foreSwap();
  509.          }
  510.          shad.visible = false;
  511.          skater.rotation = 0;
  512.          skater.y -= 20;
  513.          skater.board.wheels.visible = true;
  514.          scope.sound.setVolume("roll",0);
  515.          scope.sound.startSound("bail1",0,0,1,0);
  516.          tscore = -100;
  517.          scope.stats.clearTrickFX(false);
  518.          scope.stats.initTrickFX("bail");
  519.          scope.stats.updateBails(-1);
  520.          smode = 2;
  521.          skater.gotoAndPlay("bail_fw");
  522.          recoveryTimer.start();
  523.       }
  524.       
  525.       private function recoverInit(param1:TimerEvent) : *
  526.       {
  527.          scope.stats.clearTrickFX(true);
  528.          tscore = 0;
  529.          scope.ollieInit = false;
  530.          scope.methodInit = false;
  531.          scope.indyInit = false;
  532.          if(scope.stats.bails == 0)
  533.          {
  534.             scope.gameComplete();
  535.          }
  536.          else
  537.          {
  538.             addEventListener(Event.ENTER_FRAME,recover);
  539.          }
  540.       }
  541.       
  542.       private function hitTest() : *
  543.       {
  544.          var _loc1_:* = undefined;
  545.          var _loc2_:* = undefined;
  546.          var _loc3_:* = undefined;
  547.          var _loc4_:* = undefined;
  548.          var _loc5_:* = undefined;
  549.          var _loc6_:* = undefined;
  550.          var _loc7_:* = undefined;
  551.          var _loc8_:* = undefined;
  552.          var _loc9_:* = undefined;
  553.          _loc1_ = false;
  554.          _loc2_ = false;
  555.          _loc3_ = scope.scene.elementArray;
  556.          _loc4_ = false;
  557.          _loc5_ = 0;
  558.          while(_loc5_ < _loc3_.length)
  559.          {
  560.             if(base <= _loc3_[_loc5_].y)
  561.             {
  562.                if(Boolean(_loc3_[_loc5_].hitTestPoint(skater.x,skater.y,false)) || Boolean(_loc3_[_loc5_].hitTestPoint(skater.x + 20,skater.y,false)) || Boolean(_loc3_[_loc5_].hitTestPoint(skater.x + 40,skater.y,false)))
  563.                {
  564.                   switch(_loc3_[_loc5_].hitType)
  565.                   {
  566.                      case 0:
  567.                         if(Boolean(_loc3_[_loc5_].hitTestPoint(skater.x,skater.y,true)) || Boolean(_loc3_[_loc5_].hitTestPoint(skater.x + 20,skater.y,true)) || Boolean(_loc3_[_loc5_].hitTestPoint(skater.x + 40,skater.y,true)))
  568.                         {
  569.                            bail();
  570.                         }
  571.                         break;
  572.                      case 1:
  573.                         if(_loc3_[_loc5_].y - _loc3_[_loc5_].height + _loc3_[_loc5_].deep < skater.y)
  574.                         {
  575.                            bail();
  576.                         }
  577.                         else
  578.                         {
  579.                            scope.vy += scope.vy * -1;
  580.                            _loc4_ = true;
  581.                         }
  582.                         break;
  583.                      case 2:
  584.                         if(_loc3_[_loc5_].y - _loc3_[_loc5_].height + _loc3_[_loc5_].buffer < skater.y)
  585.                         {
  586.                            bail();
  587.                         }
  588.                         else
  589.                         {
  590.                            scope.vy += scope.vy * -1;
  591.                            _loc4_ = true;
  592.                            grind();
  593.                         }
  594.                         break;
  595.                      case 3:
  596.                         if(Boolean(_loc3_[_loc5_].ramp.hitTestPoint(skater.x,skater.y,false)) || Boolean(_loc3_[_loc5_].ramp.hitTestPoint(skater.x + 20,skater.y,false)) || Boolean(_loc3_[_loc5_].ramp.hitTestPoint(skater.x + 40,skater.y,false)))
  597.                         {
  598.                            skater.gotoAndPlay("rampUP");
  599.                            scope.vy = scope.vx * 0.75;
  600.                            skater.y -= scope.vy;
  601.                            smode = 7;
  602.                         }
  603.                         else if(_loc3_[_loc5_].y - _loc3_[_loc5_].height + _loc3_[_loc5_].buffer < skater.y)
  604.                         {
  605.                            bail();
  606.                         }
  607.                         else
  608.                         {
  609.                            scope.vy += scope.vy * -1;
  610.                            _loc4_ = true;
  611.                         }
  612.                         break;
  613.                      case 4:
  614.                         _loc9_ = 0;
  615.                         while(_loc9_ < _loc3_[_loc5_].hitpoints.length)
  616.                         {
  617.                            if(skater.hitTestPoint(_loc3_[_loc5_].x + -150 + _loc3_[_loc5_].hitpoints[_loc9_].x,_loc3_[_loc5_].y + _loc3_[_loc5_].hitpoints[_loc9_].y,true))
  618.                            {
  619.                               bail();
  620.                               break;
  621.                            }
  622.                            _loc9_++;
  623.                         }
  624.                   }
  625.                }
  626.             }
  627.             if(_loc4_)
  628.             {
  629.                _loc1_ = true;
  630.                break;
  631.             }
  632.             _loc1_ = false;
  633.             _loc5_++;
  634.          }
  635.          _loc6_ = scope.scene.foregroundArray;
  636.          _loc7_ = false;
  637.          _loc8_ = 0;
  638.          while(_loc8_ < _loc6_.length)
  639.          {
  640.             if(Boolean(_loc6_[_loc8_].hitTestPoint(skater.x,skater.y,false)) || Boolean(_loc6_[_loc8_].hitTestPoint(skater.x + 20,skater.y,false)) || Boolean(_loc6_[_loc8_].hitTestPoint(skater.x + 40,skater.y,false)))
  641.             {
  642.                switch(_loc6_[_loc8_].hitType)
  643.                {
  644.                   case 0:
  645.                      if(Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(200,base,false)) || Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(220,base,false)) || Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(240,base,false)))
  646.                      {
  647.                         if(Boolean(_loc6_[_loc8_].hitTestPoint(skater.x,skater.y,true)) || Boolean(_loc6_[_loc8_].hitTestPoint(skater.x + 20,skater.y,true)) || Boolean(_loc6_[_loc8_].hitTestPoint(skater.x + 40,skater.y,true)))
  648.                         {
  649.                            bail();
  650.                         }
  651.                      }
  652.                      break;
  653.                   case 1:
  654.                      break;
  655.                   case 2:
  656.                      if(Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(200,base,false)) || Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(220,base,false)) || Boolean(_loc6_[_loc8_].hitObj.hitTestPoint(240,base,false)))
  657.                      {
  658.                         if(_loc6_[_loc8_].y - _loc6_[_loc8_].height + _loc6_[_loc8_].buffer < skater.y)
  659.                         {
  660.                            bail();
  661.                         }
  662.                         else
  663.                         {
  664.                            scope.vy += scope.vy * -1;
  665.                            _loc7_ = true;
  666.                            grind();
  667.                         }
  668.                      }
  669.                }
  670.             }
  671.             if(_loc7_)
  672.             {
  673.                _loc2_ = true;
  674.                break;
  675.             }
  676.             _loc2_ = false;
  677.             _loc8_++;
  678.          }
  679.          if(action)
  680.          {
  681.             if(_loc2_)
  682.             {
  683.                if(scope.getChildIndex(scope.player.skater) < scope.getChildIndex(scope.scene.foreground))
  684.                {
  685.                   scope.foreSwap();
  686.                }
  687.             }
  688.             else if(scope.getChildIndex(scope.player.skater) > scope.getChildIndex(scope.scene.foreground))
  689.             {
  690.                scope.foreSwap();
  691.             }
  692.             if(_loc1_ || _loc2_)
  693.             {
  694.                contact = true;
  695.             }
  696.             else if(skater.y < base)
  697.             {
  698.                contact = false;
  699.             }
  700.             else
  701.             {
  702.                contact = true;
  703.             }
  704.          }
  705.       }
  706.       
  707.       public function starFX(param1:*, param2:*, param3:*, param4:*) : *
  708.       {
  709.          var _loc5_:* = undefined;
  710.          var _loc6_:* = undefined;
  711.          var _loc7_:MovieClip = null;
  712.          _loc5_ = param1 + Math.round(Math.random() * (param2 - param1));
  713.          _loc6_ = 0;
  714.          while(_loc6_ < _loc5_)
  715.          {
  716.             (_loc7_ = new star1(skaterFX,scope)).x = param3;
  717.             _loc7_.y = param4;
  718.             skaterFX.addChild(_loc7_);
  719.             _loc6_++;
  720.          }
  721.       }
  722.    }
  723. }
  724.